测试开发面试真题—算法（百度）

1、请列举常用的算法，并说明其时间复杂读，并说明排序思想？

①冒泡排序：量量比较待排序数据元素的大小，发现两个数据元素的次序相反时进行交换，直到没有反序的数据元素为止。时间复杂度是O(n*2)。稳定的。

public class bubble1 {
	public static void main(String[] args) {
		int[] array = { 7, 8, 3, 1, 5, 2, 9, 6, 4 };
		printArray(array);
		bubbleSort(array);
		printArray(array);
	}

	private static void bubbleSort(int[] array) {
		for (int i = 0; i < array.length; i++) {
			for (int j = i + 1; j < array.length; j++) {
				if (array[i] > array[j]) {
					int temp = array[i];
					array[i] = array[j];
					array[j] = temp;
				}
			}
		}
	}

	private static void printArray(int[] array) {
		if (array.length == 0 || array == null) {
			return;
		}
		for (int i = 0; i < array.length - 1; i++) {
			System.out.print(array[i] + " ");
		}
		System.out.println(array[array.length - 1]);
	}
}

public class bubble2 {
	public static void main(String[] args) {
		int[] array = { 7, 8, 3, 1, 5, 2, 9, 6, 4 };
		printArray(array);
		bubbleSort(array);
		printArray(array);
	}

	private static void bubbleSort(int[] array) {
		for (int i = 0; i < array.length; i++) {
			for (int j = array.length - 2; j >= i; j--) {
				if (array[j] > array[j + 1]) {
					int temp = array[j];
					array[j] = array[j + 1];
					array[j + 1] = temp;
				}
			}
		}
	}

	private static void printArray(int[] array) {
		if (array.length == 0 || array == null) {
			return;
		}
		for (int i = 0; i < array.length - 1; i++) {
			System.out.print(array[i] + " ");
		}
		System.out.println(array[array.length - 1]);
	}
}

②选择排序：每一趟从待排序的数据元素中选出最小（最大）的一个元素，顺序放在已经排好序的数列的最后面，

直到全部待排序的数据元素排完，算法复杂度是O(n*2)。不稳定的。

public class select {
	public static void main(String[] args) {
		int[] array = { 0, 8, 3, 1, 5, 2, 9, 6, 4 };
		printArray(array);
		selectSort(array);
		printArray(array);
	}

	private static void selectSort(int[] array) {
		int k = 0;
		for (int i = 0; i < array.length; i++) {
			k = i;
			for (int j = i; j < array.length; j++) {
				if (array[j] < array[k]) {
					k = j;
				}
			}
			int temp = array[i];
			array[i] = array[k];
			array[k] = temp;
		}

	}

	private static void printArray(int[] array) {
		if (array.length == 0 || array == null) {
			return;
		}
		for (int i = 0; i < array.length - 1; i++) {
			System.out.print(array[i] + " ");
		}
		System.out.println(array[array.length - 1]);
	}
}

③插入排序：每次将一个待排序的数据元素，插入到前面已经排好序的数列中的适当位置，使数列依然有序；直到待排序数据元素全部插入完为止。

算法的时间复杂度是o(n*2）。稳定的。

public class insert {
	public static void main(String[] args) {
		int[] array = { 0, 8, 3, 1, 5, 2, 9, 6, 4 };
		printArray(array);
		insertSort(array);
		printArray(array);
	}

	private static void insertSort(int[] array) {
		int temp = 0;
		for (int i = 1; i < array.length; i++) {
			temp = array[i];
			int j = 0;
			for (j = i; j > 0; j--) {
				if (array[j - 1] > temp) {
					array[j] = array[j - 1];
				} else {
					break;
				}
			}
			array[j] = temp;
		}
	}

	private static void printArray(int[] array) {
		if (array.length == 0 || array == null) {
			return;
		}
		for (int i = 0; i < array.length - 1; i++) {
			System.out.print(array[i] + " ");
		}
		System.out.println(array[array.length - 1]);
	}
}

④快速排序：在当前无序区 R[1..H]中任取一个数据元素作为比较的"基准"(不妨记为 X)，用此基准将当前无序区划分为左右两个较小的无序区：R[1..I-1]和 R[I+1..H]，

且左边的无序子区中数据元素均小于等于基准元素，右边的无序子区中数据元素均大于等于基准元素，而基准 X 则位于最终排序的位置上，

即R[1..I-1]≤X.Key≤R[I+1..H](1≤I≤H)，当 R[1..I-1]和 R[I+1..H]均非空时，分别对它们进行上述的划分过程，直至所有无序子区中的数据元素均已排序为止。

最理想情况算法时间复杂度 O(nlogn)，最坏O(n^2) 。不稳定。